home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / wmanager.cpp < prev    next >
C/C++ Source or Header  |  1994-10-10  |  4KB  |  166 lines
  1. #include <stdlib.h>
  2. #include "wmanager.h"
  3. #include "alloc.h"
  4.  
  5. int* dump(int* cells)
  6.     {
  7.     int i = 0;
  8.     int j = 0;
  9.     int* cells1 = cells;
  10.     while(cells[i] != -1 && i < 25 * 80)
  11.         {
  12.         if(cells[i] == -2)
  13.             {
  14.             i++;
  15.             continue;
  16.         }
  17.         cells1[j] = cells[i];
  18.         i++; j++;
  19.     }
  20.     cells1[j] = -1;
  21.     return cells1;
  22.     }
  23. /////////////////////////
  24. int WindowManager::overlapped(Visible* object)
  25.     {
  26.     int num = get_number(object);
  27.     rect r = object->bound();
  28.     for(int i = num + 1; i <= s_used; i++)
  29.         {
  30.         rect b = stack[i]->bound();
  31.         if(b.contains(r.origin) || b.contains(r.corner)
  32.            || r.contains(b.origin) || r.contains(b.corner)
  33.            || (r.origin.X <= b.origin.X
  34.         && r.corner.X >= b.origin.X
  35.         && r.origin.Y >= b.origin.Y
  36.         && r.origin.Y <= b.corner.Y)
  37.            || (r.origin.X >= b.origin.X
  38.             && r.origin.X <= b.corner.X
  39.             && r.origin.Y <= b.origin.Y
  40.             && r.corner.Y >= b.origin.Y))
  41.             return 1;
  42.         }
  43.     return 0;
  44.     }
  45. /////////////////////////
  46. WindowManager::~WindowManager()
  47.     {
  48.     char str[9];
  49.     for(int i = 0; i <= s_used; i++)
  50.         unlink(get_file_name(stack[i], str));
  51.     delete stack;
  52.     }
  53. ////////////////////////
  54. int* WindowManager::get_cells()
  55.     {
  56.     rect cur_rect = stack[s_used]->bound();
  57.  
  58.     return pScreenSet->get_cells(cur_rect);
  59.     }
  60. /////////////////////////
  61. int WindowManager::get_number(Visible* object)
  62.     {
  63.     for(int i = 0; object != stack[i]; i++)
  64.         ;
  65.     return i;
  66.     }
  67. ///////////////////////
  68. void WindowManager::add(Visible* object)
  69.     {
  70.     s_used++;
  71.     stack[s_used] = object;
  72.  
  73.     if(s_size < s_used)
  74.     stack = (Visible**)realloc(stack,
  75.         (s_size += DELTA) * sizeof(Visible*));
  76.     }
  77. ////////////////////
  78. void WindowManager::moveTo(Visible* object)
  79.     {
  80.     int i = get_number(object);
  81.     for(; i < s_used; i++)    // Move object to the top
  82.     stack[i] = stack[i + 1];
  83.     stack[s_used] = object;
  84.     }
  85. ///////////////////////////
  86. void WindowManager::shift()
  87.     {
  88.     if(s_used > 1)
  89.     moveTo(stack[1]);
  90.     }
  91. ///////////////////////////
  92. void WindowManager::remove()
  93.     {
  94.     s_used--;
  95.     if(s_size - s_used > 2 * DELTA)
  96.     stack = (Visible**)realloc(stack, (s_size -= DELTA) * sizeof(int));
  97.     }
  98. /////////////////////////
  99. char* WindowManager::get_file_name(Visible* object, char* str)
  100.     {
  101.     int i = object->get_object_number();
  102.     itoa(i, str, 10);
  103.     return str;
  104.     }
  105. /////////////////////////////
  106. void WindowManager::show_window(Visible* object)
  107.     {
  108.     if(!object->active())
  109.     add(object);
  110.  
  111.     char str[9];
  112.     if(object->isRet(RET_STACKED))
  113.     {
  114.     if(!object->active() || overlapped(object))
  115.         {
  116.         object->show();
  117.         if(!object->isRet(RET_SHOW))
  118.         pcx_scr_file(object->bound(), get_file_name(object, str), 0);
  119.         }
  120.     }
  121.     else if(!object->active())
  122.     {
  123.     pcx_scr_file(object->bound(), get_file_name(object, str), 0);
  124.         object->show();
  125.     }
  126.     moveTo(object);
  127.     stack[s_used]->set_active(1);
  128.     }
  129. //////////////////////
  130. void WindowManager::hide_window()
  131.     {
  132.     char str[9];
  133.     if(stack[s_used]->isRet(RET_STACKED))
  134.         {
  135.         int* cells = get_cells();
  136.         for(int i = s_used - 1; i >= 0; i--)
  137.             {
  138.             pcx_file_scr(get_file_name(stack[i], str),
  139.             stack[i]->bound().origin, cells);
  140.             cells = dump(cells);
  141.             }
  142.         delete cells;
  143.     }
  144.     else
  145.         {
  146.         pcx_file_scr(get_file_name(stack[s_used], str),
  147.         stack[s_used]->bound().origin);
  148.         stack[s_used]->hide();  // Final operations, delete, close ...
  149.     }                       // For STACKED windows it does destructor.
  150.     stack[s_used]->set_active(0);
  151.     unlink(get_file_name(stack[s_used], str));
  152.     remove();
  153.     }
  154. //////////////////////
  155. void WindowManager::redraw_window(rect new_coord)
  156.     {
  157.     if(new_coord.origin.X == new_coord.corner.X)
  158.         return;
  159.     Visible* tmp = stack[s_used];
  160.     hide_window();
  161.     tmp->repose(textRect(new_coord));
  162.     show_window(tmp);
  163.     }
  164. //////////////////////
  165.  
  166.